home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / src / TreeC1.mi < prev    next >
Text File  |  1992-11-24  |  62KB  |  1,875 lines
  1. IMPLEMENTATION MODULE TreeC1;
  2.  
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15. IMPORT SYSTEM, System, IO, Tree;
  16. (* line 11 "" *)
  17.  
  18.  
  19. FROM General    IMPORT Max;
  20. FROM IO        IMPORT WriteS, WriteNl;
  21. FROM Idents    IMPORT tIdent;
  22. FROM Texts    IMPORT WriteText;
  23. FROM Sets    IMPORT IsElement, Include;
  24. FROM TreeC2    IMPORT TreeIO, GetIterator, Iterator, WriteLine;
  25.  
  26. FROM Tree    IMPORT
  27.    NoTree    , tTree        , Input        , Reverse    ,
  28.    Class    , Child        , Attribute    , Abstract    ,
  29.    HasChildren    , HasAttributes    , NoCodeAttr    , NoCodeClass    ,
  30.    Options    , TreeRoot    , ClassCount    , iNoTree    ,
  31.    itTree    , iMain        , iModule    , f        ,
  32.    WI    , WN    , ForallClasses    , ForallAttributes, Ignore    ,
  33.    Test        , Dummy        ;
  34.  
  35. IMPORT Strings;
  36.  
  37. VAR
  38.    ConstCount    ,
  39.    ListCount    : INTEGER;
  40.    iRange    ,
  41.    iClassName    : tIdent;
  42.    Node        : tTree;
  43.    gBitCount    : SHORTCARD;
  44.    i, MaxBit    : SHORTCARD;
  45.  
  46.  
  47.  
  48.  
  49.  
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59.  
  60.  
  61.  
  62.  
  63.  
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70.  
  71.  
  72.  
  73.  
  74.  
  75.  
  76.  
  77.  
  78.  
  79.  
  80.  
  81.  
  82.  
  83.  
  84.  
  85.  
  86.  
  87.  
  88.  
  89.  
  90.  
  91.  
  92.  
  93.  
  94.  
  95.  
  96.  
  97.  
  98.  
  99.  
  100.  
  101.  
  102.  
  103.  
  104.  
  105.  
  106.  
  107.  
  108.  
  109.  
  110.  
  111.  
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120.  
  121.  
  122.  
  123.  
  124.  
  125.  
  126.  
  127.  
  128.  
  129.  
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136.  
  137.  
  138.  
  139.  
  140.  
  141.  
  142.  
  143.  
  144.  
  145. PROCEDURE yyAbort (yyFunction: ARRAY OF CHAR);
  146.  BEGIN
  147.   IO.WriteS (IO.StdError, 'Error: module TreeC1, routine ');
  148.   IO.WriteS (IO.StdError, yyFunction);
  149.   IO.WriteS (IO.StdError, ' failed');
  150.   IO.WriteNl (IO.StdError);
  151.   Exit;
  152.  END yyAbort;
  153.  
  154. PROCEDURE yyIsEqual (yya, yyb: ARRAY OF SYSTEM.BYTE): BOOLEAN;
  155.  VAR yyi    : INTEGER;
  156.  BEGIN
  157.   FOR yyi := 0 TO INTEGER (HIGH (yya)) DO
  158.    IF yya [yyi] # yyb [yyi] THEN RETURN FALSE; END;
  159.   END;
  160.   RETURN TRUE;
  161.  END yyIsEqual;
  162.  
  163. PROCEDURE TreeDefC (t: Tree.tTree);
  164.  VAR yyTempo: RECORD CASE : INTEGER OF
  165.  END; END;
  166.  BEGIN
  167.   IF t = Tree.NoTree THEN RETURN; END;
  168.   IF (t^.Kind = Tree.Ag) THEN
  169. (* line 45 "" *)
  170.      WITH t^.Ag DO
  171. (* line 45 "" *)
  172.       
  173.     WriteS (f, "# ifndef yy"); WI (iModule); WriteNl (f);
  174.     WriteS (f, "# define yy"); WI (iModule); WriteNl (f);
  175.     WriteNl (f);
  176.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  177.     WriteS (f, "# define ARGS(parameters)    parameters"); WriteNl (f);
  178.     WriteS (f, "# else"); WriteNl (f);
  179.     WriteS (f, "# define ARGS(parameters)    ()"); WriteNl (f);
  180.     WriteS (f, "# endif"); WriteNl (f);
  181.     WriteNl (f);
  182.       IF IsElement (ORD ('<'), Options) THEN
  183.     WriteS (f, '# include "'); WI (iMain); WriteS (f, '.h"'); WriteNl (f);
  184.       END;
  185.     WriteLine (TreeCodes^.Codes.ImportLine);
  186.     WriteText (f, TreeCodes^.Codes.Import);
  187.     Node := Modules;
  188.     WHILE Node^.Kind = Tree.Module DO
  189.        WriteLine (Node^.Module.TreeCodes^.Codes.ImportLine);
  190.        WriteText (f, Node^.Module.TreeCodes^.Codes.Import);
  191.        Node := Node^.Module.Next;
  192.     END;
  193.     WriteNl (f);
  194.     WriteS (f, "# ifndef bool"); WriteNl (f);
  195.     WriteS (f, "# define bool char"); WriteNl (f);
  196.     WriteS (f, "# endif"); WriteNl (f);
  197.       IF NOT IsElement (ORD ('<'), Options) THEN
  198.     WriteS (f, "# define "); WI (iNoTree); WriteS (f, " ("); WI (itTree); WriteS (f, ") 0L"); WriteNl (f);
  199.     ForallClasses (Classes, ConstDecls);
  200.     WriteNl (f);
  201.     IF ClassCount > 251 THEN
  202.     WriteS (f, "typedef unsigned short "); WI (iMain); WriteS (f, "_tKind;"); WriteNl (f);
  203.     ELSE
  204.     WriteS (f, "typedef unsigned char "); WI (iMain); WriteS (f, "_tKind;"); WriteNl (f);
  205.     END;
  206.     WriteS (f, "typedef unsigned short "); WI (iMain); WriteS (f, "_tMark;"); WriteNl (f);
  207.     WriteS (f, "typedef unsigned short "); WI (iMain); WriteS (f, "_tLabel;"); WriteNl (f);
  208.     WriteS (f, "typedef union "); WI (iMain); WriteS (f, "_Node * "); WI (itTree); WriteS (f, ";"); WriteNl (f);
  209.     WriteS (f, "typedef void (* "); WI (iMain); WriteS (f, "_tProcTree) ARGS(("); WI (itTree); WriteS (f, "));"); WriteNl (f);
  210.       END;
  211.     WriteLine (TreeCodes^.Codes.ExportLine);
  212.     WriteText (f, TreeCodes^.Codes.Export);
  213.     Node := Modules;
  214.     WHILE Node^.Kind = Tree.Module DO
  215.        WriteLine (Node^.Module.TreeCodes^.Codes.ExportLine);
  216.        WriteText (f, Node^.Module.TreeCodes^.Codes.Export);
  217.        Node := Node^.Module.Next;
  218.     END;
  219.     WriteNl (f);
  220.       IF NOT IsElement (ORD ('<'), Options) THEN
  221.     WriteS (f, "# ifndef "); WI (iMain); WriteS (f, "_NodeHead"); WriteNl (f);
  222.     WriteS (f, "# define "); WI (iMain); WriteS (f, "_NodeHead"); WriteNl (f);
  223.     WriteS (f, "# endif"); WriteNl (f);
  224.       IF IsElement (ORD ('L'), Options) THEN
  225.     MaxBit := 0;
  226.     ForallClasses (Classes, CompMaxBit);
  227.     WriteS (f, "typedef struct { "); WI (iMain); WriteS (f, "_tKind yyKind; unsigned char yyIsComp0"); 
  228.       IF IsElement (ORD ('5'), Options) THEN
  229.     WriteS (f, ", yyIsDone0"); 
  230.       END;
  231.     FOR i := 1 TO (MaxBit - 1) DIV BSS DO
  232.        WriteS (f, ", yyIsComp"); WN (i);
  233.       IF IsElement (ORD ('5'), Options) THEN
  234.        WriteS (f, ", yyIsDone"); WN (i);
  235.       END;
  236.     END;
  237.     WriteS (f, "; "); WI (iMain); WriteS (f, "_tMark yyMark, yyOffset; "); WI (itTree); WriteS (f, " yyParent; "); 
  238.     WI (iMain); WriteS (f, "_NodeHead } "); WI (iMain); WriteS (f, "_tNodeHead;"); WriteNl (f);
  239.       ELSE
  240.     WriteS (f, "typedef struct { "); WI (iMain); WriteS (f, "_tKind yyKind; "); WI (iMain); WriteS (f, "_tMark yyMark; "); 
  241.     WI (iMain); WriteS (f, "_NodeHead } "); WI (iMain); WriteS (f, "_tNodeHead;"); WriteNl (f);
  242.       END;
  243.     ForallClasses (Classes, TypeDeclNode);
  244.     WriteNl (f);
  245.     WriteS (f, "union "); WI (iMain); WriteS (f, "_Node {"); WriteNl (f);
  246.     WriteS (f, " "); WI (iMain); WriteS (f, "_tKind Kind;"); WriteNl (f);
  247.     WriteS (f, " "); WI (iMain); WriteS (f, "_tNodeHead yyHead;"); WriteNl (f);
  248.     ForallClasses (Classes, TypeDeclRecord);
  249.     WriteS (f, "};"); WriteNl (f);
  250.     WriteNl (f);
  251.     WriteS (f, "extern "); WI (itTree); WriteS (f, " "); WI (iMain); WriteS (f, "Root;"); WriteNl (f);
  252.     WriteS (f, "extern unsigned long "); WI (iMain); WriteS (f, "_HeapUsed;"); WriteNl (f);
  253.     WriteS (f, "extern char * "); WI (iMain); WriteS (f, "_PoolFreePtr, * "); WI (iMain); WriteS (f, "_PoolMaxPtr;"); WriteNl (f);
  254.     WriteS (f, "extern unsigned short "); WI (iMain); WriteS (f, "_NodeSize ["); WN (ClassCount); WriteS (f, " + 1];"); WriteNl (f);
  255.     WriteS (f, "extern char * "); WI (iMain); WriteS (f, "_NodeName ["); WN (ClassCount); WriteS (f, " + 1];"); WriteNl (f);
  256.     WriteNl (f);
  257.     WriteS (f, "extern void (* "); WI (iMain); WriteS (f, "_Exit) ();"); WriteNl (f);
  258.     WriteS (f, "extern "); WI (itTree); WriteS (f, " "); WI (iMain); WriteS (f, "_Alloc ();"); WriteNl (f);
  259.     WriteS (f, "extern "); WI (itTree); WriteS (f, " Make"); WI (iMain); WriteS (f, " ARGS(("); WI (iMain); WriteS (f, "_tKind yyKind));"); WriteNl (f);
  260.     WriteS (f, "extern bool "); WI (iMain); WriteS (f, "_IsType ARGS((register "); WI (itTree); WriteS (f, " yyt, register "); WI (iMain); WriteS (f, "_tKind yyKind));"); WriteNl (f);
  261.     WriteNl (f);
  262.       END;
  263.       IF IsElement (ORD ('n'), Options) THEN
  264.     ForallClasses (Classes, ProcedureDeclsn);
  265.     WriteNl (f);
  266.       END;
  267.       IF IsElement (ORD ('m'), Options) THEN
  268.     ForallClasses (Classes, ProcedureDeclsm);
  269.     WriteNl (f);
  270.       END;
  271.       IF IsElement (ORD ('f'), Options) THEN
  272.     WriteS (f, "extern void Release"); WI (iModule); WriteS (f, " ARGS(("); WI (itTree); WriteS (f, " yyt));"); WriteNl (f);
  273.       END;
  274.       IF IsElement (ORD ('F'), Options) AND NOT IsElement (ORD ('<'), Options) THEN
  275.     WriteS (f, "extern void Release"); WI (iModule); WriteS (f, "Module ();"); WriteNl (f);
  276.       END;
  277.       IF IsElement (ORD ('o'), Options) THEN
  278.     WriteS (f, "extern void Write"); WI (iModule); WriteS (f, "Node ARGS((FILE * yyyf, "); WI (itTree); WriteS (f, " yyt));"); WriteNl (f);
  279.       END;
  280.       IF IsElement (ORD ('w'), Options) THEN
  281.     WriteS (f, "extern void Write"); WI (iModule); WriteS (f, " ARGS((FILE * yyyf, "); WI (itTree); WriteS (f, " yyt));"); WriteNl (f);
  282.       END;
  283.       IF IsElement (ORD ('r'), Options) THEN
  284.     WriteS (f, "extern "); WI (itTree); WriteS (f, " Read"); WI (iModule); WriteS (f, " ARGS((FILE * yyyf));"); WriteNl (f);
  285.       END;
  286.       IF IsElement (ORD ('p'), Options) THEN
  287.     WriteS (f, "extern void Put"); WI (iModule); WriteS (f, " ARGS((FILE * yyyf, "); WI (itTree); WriteS (f, " yyt));"); WriteNl (f);
  288.       END;
  289.       IF IsElement (ORD ('g'), Options) THEN
  290.     WriteS (f, "extern "); WI (itTree); WriteS (f, " Get"); WI (iModule); WriteS (f, " ARGS((FILE * yyyf));"); WriteNl (f);
  291.       END;
  292.       IF IsElement (ORD ('t'), Options) THEN
  293.     WriteS (f, "extern void Traverse"); WI (iModule); WriteS (f, "TD ARGS(("); WI (itTree); WriteS (f, " yyt, "); WI (iMain); WriteS (f, "_tProcTree yyyProc));"); WriteNl (f);
  294.       END;
  295.       IF IsElement (ORD ('b'), Options) THEN
  296.     WriteS (f, "extern void Traverse"); WI (iModule); WriteS (f, "BU ARGS(("); WI (itTree); WriteS (f, " yyt, "); WI (iMain); WriteS (f, "_tProcTree yyyProc));"); WriteNl (f);
  297.       END;
  298.       IF IsElement (ORD ('R'), Options) THEN
  299.     WriteS (f, "extern "); WI (itTree); WriteS (f, " Reverse"); WI (iModule); WriteS (f, " ARGS(("); WI (itTree); WriteS (f, " yyOld));"); WriteNl (f);
  300.       END;
  301.       IF IsElement (ORD ('y'), Options) THEN
  302.     WriteS (f, "extern "); WI (itTree); WriteS (f, " Copy"); WI (iModule); WriteS (f, " ARGS(("); WI (itTree); WriteS (f, " yyt));"); WriteNl (f);
  303.       END;
  304.       IF IsElement (ORD ('k'), Options) THEN
  305.     WriteS (f, "extern bool Check"); WI (iModule); WriteS (f, " ARGS(("); WI (itTree); WriteS (f, " yyt));"); WriteNl (f);
  306.       END;
  307.       IF IsElement (ORD ('q'), Options) THEN
  308.     WriteS (f, "extern void Query"); WI (iModule); WriteS (f, " ARGS(("); WI (itTree); WriteS (f, " yyt));"); WriteNl (f);
  309.       END;
  310.       IF IsElement (ORD ('='), Options) THEN
  311.     WriteS (f, "extern bool IsEqual"); WI (iModule); WriteS (f, " ARGS(("); WI (itTree); WriteS (f, " yyt1, "); WI (itTree); WriteS (f, " yyt2));"); WriteNl (f);
  312.       END;
  313.       IF IsElement (ORD ('L'), Options) THEN
  314.     WriteS (f, "extern void Init"); WI (iModule); WriteS (f, " ARGS((register "); WI (itTree); WriteS (f, " yyt));"); WriteNl (f);
  315.       END;
  316.     WriteS (f, "extern void Begin"); WI (iModule); WriteS (f, " ();"); WriteNl (f);
  317.     WriteS (f, "extern void Close"); WI (iModule); WriteS (f, " ();"); WriteNl (f);
  318.     WriteNl (f);
  319.     WriteS (f, "# endif"); WriteNl (f);
  320. ;
  321.       RETURN;
  322.      END;
  323.  
  324.   END;
  325.  END TreeDefC;
  326.  
  327. PROCEDURE ConstDecls (t: Tree.tTree);
  328.  VAR yyTempo: RECORD CASE : INTEGER OF
  329.  END; END;
  330.  BEGIN
  331.   IF t = Tree.NoTree THEN RETURN; END;
  332.   IF (t^.Kind = Tree.Class) THEN
  333. (* line 198 "" *)
  334.      WITH t^.Class DO
  335. (* line 198 "" *)
  336.       
  337.     IF NOT (Abstract IN Properties) THEN
  338.        INC (ConstCount);
  339.        IF NOT (Ignore IN Properties) THEN
  340.           WriteS (f, "# define k"); WI (Name); WriteS (f, " "); WN (ConstCount); WriteNl (f);
  341.        END;
  342.     END;
  343. ;
  344.       RETURN;
  345.      END;
  346.  
  347.   END;
  348.  END ConstDecls;
  349.  
  350. PROCEDURE TypeDeclNode (t: Tree.tTree);
  351.  VAR yyTempo: RECORD CASE : INTEGER OF
  352.  END; END;
  353.  BEGIN
  354.   IF t = Tree.NoTree THEN RETURN; END;
  355.   IF (t^.Kind = Tree.Class) THEN
  356. (* line 210 "" *)
  357.      WITH t^.Class DO
  358. (* line 210 "" *)
  359.       
  360.     IF (NoCodeClass * Properties) = {} THEN
  361.        WriteS (f, "typedef struct { "); WI (iMain); WriteS (f, "_tNodeHead yyHead; "); 
  362.        ForallAttributes (t, TypeDeclNode);
  363.        WriteS (f, "} y"); WI (Name); WriteS (f, ";"); WriteNl (f);
  364.     END;
  365. ;
  366.       RETURN;
  367.      END;
  368.  
  369.   END;
  370.   IF (t^.Kind = Tree.Child) THEN
  371. (* line 217 "" *)
  372.      WITH t^.Child DO
  373. (* line 217 "" *)
  374.       
  375.     WI (itTree); WriteS (f, " "); WI (Name); WriteS (f, "; "); 
  376. ;
  377.       RETURN;
  378.      END;
  379.  
  380.   END;
  381.   IF (t^.Kind = Tree.Attribute) THEN
  382. (* line 220 "" *)
  383.      WITH t^.Attribute DO
  384. (* line 220 "" *)
  385.       
  386.     IF (NoCodeAttr * Properties) = {} THEN 
  387.        WI (Type); WriteS (f, " "); WI (Name); WriteS (f, "; "); 
  388.     END;
  389. ;
  390.       RETURN;
  391.      END;
  392.  
  393.   END;
  394.  END TypeDeclNode;
  395.  
  396. PROCEDURE TypeDeclRecord (t: Tree.tTree);
  397.  VAR yyTempo: RECORD CASE : INTEGER OF
  398.  END; END;
  399.  BEGIN
  400.   IF t = Tree.NoTree THEN RETURN; END;
  401.   IF (t^.Kind = Tree.Class) THEN
  402. (* line 229 "" *)
  403.      WITH t^.Class DO
  404. (* line 229 "" *)
  405.       
  406.     IF (NoCodeClass * Properties) = {} THEN
  407.        WriteS (f, " y"); WI (Name); WriteS (f, " "); WI (Name); WriteS (f, ";"); WriteNl (f);
  408.     END;
  409. ;
  410.       RETURN;
  411.      END;
  412.  
  413.   END;
  414.  END TypeDeclRecord;
  415.  
  416. PROCEDURE ProcedureDeclsn (t: Tree.tTree);
  417.  VAR yyTempo: RECORD CASE : INTEGER OF
  418.  END; END;
  419.  BEGIN
  420.   IF t = Tree.NoTree THEN RETURN; END;
  421.   IF (t^.Kind = Tree.Class) THEN
  422. (* line 238 "" *)
  423.      WITH t^.Class DO
  424. (* line 238 "" *)
  425.       
  426.     IF (NoCodeClass * Properties) = {} THEN
  427.        WriteS (f, "extern "); WI (itTree); WriteS (f, " n"); WI (Name); WriteS (f, " ();"); WriteNl (f);
  428.     END;
  429. ;
  430.       RETURN;
  431.      END;
  432.  
  433.   END;
  434.  END ProcedureDeclsn;
  435.  
  436. PROCEDURE ProcedureDeclsm (t: Tree.tTree);
  437.  VAR yyTempo: RECORD CASE : INTEGER OF
  438.  END; END;
  439.  BEGIN
  440.   IF t = Tree.NoTree THEN RETURN; END;
  441.   IF (t^.Kind = Tree.Class) THEN
  442. (* line 247 "" *)
  443.      WITH t^.Class DO
  444. (* line 247 "" *)
  445.       
  446.     IF (NoCodeClass * Properties) = {} THEN
  447.        WriteS (f, "extern "); WI (itTree); WriteS (f, " m"); WI (Name); WriteS (f, " ARGS(("); 
  448.        ListCount := 0;
  449.        ForallAttributes (t, ProcedureDeclsm);
  450.        WriteS (f, "));"); WriteNl (f);
  451.     END;
  452. ;
  453.       RETURN;
  454.      END;
  455.  
  456.   END;
  457.   IF (t^.Kind = Tree.Child) THEN
  458. (* line 255 "" *)
  459.      WITH t^.Child DO
  460. (* line 255 "" *)
  461.       
  462.     IF Input IN Properties THEN
  463.        IF ListCount > 0 THEN WriteS (f, ", "); END;
  464.        WI (itTree); WriteS (f, " p"); WI (Name);
  465.        INC (ListCount);
  466.     END;
  467. ;
  468.       RETURN;
  469.      END;
  470.  
  471.   END;
  472.   IF (t^.Kind = Tree.Attribute) THEN
  473. (* line 262 "" *)
  474.      WITH t^.Attribute DO
  475. (* line 262 "" *)
  476.       
  477.     IF Input IN Properties THEN
  478.        IF ListCount > 0 THEN WriteS (f, ", "); END;
  479.        WI (Type); WriteS (f, " p"); WI (Name);
  480.        INC (ListCount);
  481.     END;
  482. ;
  483.       RETURN;
  484.      END;
  485.  
  486.   END;
  487.  END ProcedureDeclsm;
  488.  
  489. PROCEDURE ProcedureHeadingm (t: Tree.tTree);
  490.  VAR yyTempo: RECORD CASE : INTEGER OF
  491.  END; END;
  492.  BEGIN
  493.   IF t = Tree.NoTree THEN RETURN; END;
  494.   IF (t^.Kind = Tree.Class) THEN
  495. (* line 273 "" *)
  496.      WITH t^.Class DO
  497. (* line 273 "" *)
  498.       
  499.     IF (NoCodeClass * Properties) = {} THEN
  500.        WI (itTree); WriteS (f, " m"); WI (Name); WriteNl (f);
  501.        WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  502.        ListCount := 0;
  503.        WriteS (f, "("); ForallAttributes (t, ProcedureDeclsm); WriteS (f, ")"); WriteNl (f);
  504.        WriteS (f, "# else"); WriteNl (f);
  505.        ListCount := 0;
  506.        WriteS (f, "("); ForallAttributes (t, ProcedureHeadingm); WriteS (f, ")"); WriteNl (f);
  507.        ForallAttributes (t, ProcedureHeadingm2);
  508.        WriteS (f, "# endif"); WriteNl (f);
  509.     END;
  510. ;
  511.       RETURN;
  512.      END;
  513.  
  514.   END;
  515.   IF (t^.Kind = Tree.Child) THEN
  516. (* line 286 "" *)
  517.      WITH t^.Child DO
  518. (* line 286 "" *)
  519.       
  520.     IF Input IN Properties THEN
  521.        IF ListCount > 0 THEN WriteS (f, ", "); END;
  522.        WriteS (f, "p"); WI (Name);
  523.        INC (ListCount);
  524.     END;
  525. ;
  526.       RETURN;
  527.      END;
  528.  
  529.   END;
  530.   IF (t^.Kind = Tree.Attribute) THEN
  531. (* line 293 "" *)
  532.      WITH t^.Attribute DO
  533. (* line 293 "" *)
  534.       
  535.     IF Input IN Properties THEN
  536.        IF ListCount > 0 THEN WriteS (f, ", "); END;
  537.        WriteS (f, "p"); WI (Name);
  538.        INC (ListCount);
  539.     END;
  540. ;
  541.       RETURN;
  542.      END;
  543.  
  544.   END;
  545.  END ProcedureHeadingm;
  546.  
  547. PROCEDURE ProcedureHeadingm2 (t: Tree.tTree);
  548.  VAR yyTempo: RECORD CASE : INTEGER OF
  549.  END; END;
  550.  BEGIN
  551.   IF t = Tree.NoTree THEN RETURN; END;
  552.   IF (t^.Kind = Tree.Child) THEN
  553. (* line 304 "" *)
  554.      WITH t^.Child DO
  555. (* line 304 "" *)
  556.       
  557.     IF Input IN Properties THEN
  558.        WI (itTree); WriteS (f, " p"); WI (Name); WriteS (f, ";"); WriteNl (f);
  559.     END;
  560. ;
  561.       RETURN;
  562.      END;
  563.  
  564.   END;
  565.   IF (t^.Kind = Tree.Attribute) THEN
  566. (* line 309 "" *)
  567.      WITH t^.Attribute DO
  568. (* line 309 "" *)
  569.       
  570.     IF Input IN Properties THEN
  571.        WI (Type); WriteS (f, " p"); WI (Name); WriteS (f, ";"); WriteNl (f);
  572.     END;
  573. ;
  574.       RETURN;
  575.      END;
  576.  
  577.   END;
  578.  END ProcedureHeadingm2;
  579.  
  580. PROCEDURE TreeImplC (t: Tree.tTree);
  581.  VAR yyTempo: RECORD CASE : INTEGER OF
  582.  END; END;
  583.  BEGIN
  584.   IF t = Tree.NoTree THEN RETURN; END;
  585.   IF (t^.Kind = Tree.Ag) THEN
  586. (* line 318 "" *)
  587.      WITH t^.Ag DO
  588. (* line 318 "" *)
  589.       
  590.     WriteS (f, '# include "'); WI (iMain); WriteS (f, '.h"'); WriteNl (f);
  591.     WriteS (f, "# define yyALLOC(ptr, size)    if ((ptr = ("); WI (itTree); WriteS (f, ") "); WI (iMain); WriteS (f, "_PoolFreePtr) >= ("); WI (itTree); WriteS (f, ") "); WI (iMain); WriteS (f, "_PoolMaxPtr) \"); WriteNl (f);
  592.     WriteS (f, "  ptr = "); WI (iMain); WriteS (f, "_Alloc (); \"); WriteNl (f);
  593.     WriteS (f, "  "); WI (iMain); WriteS (f, "_PoolFreePtr += size;"); WriteNl (f);
  594.     WriteS (f, "# define yyFREE(ptr, size)    "); WriteNl (f);
  595.     WriteS (f, "# include <stdio.h>"); WriteNl (f);
  596.     WriteS (f, "# ifdef __cplusplus"); WriteNl (f);
  597.     WriteS (f, 'extern "C" {'); WriteNl (f);
  598.     WriteS (f, '# include "System.h"'); WriteNl (f);
  599.     WriteS (f, '# include "General.h"'); WriteNl (f);
  600.     WriteS (f, '# include "Memory.h"'); WriteNl (f);
  601.     WriteS (f, '# include "DynArray.h"'); WriteNl (f);
  602.     WriteS (f, '# include "StringMem.h"'); WriteNl (f);
  603.     WriteS (f, '# include "Idents.h"'); WriteNl (f);
  604.     WriteS (f, '# include "Sets.h"'); WriteNl (f);
  605.     WriteS (f, '# include "Positions.h"'); WriteNl (f);
  606.     WriteS (f, "}"); WriteNl (f);
  607.     WriteS (f, "# else"); WriteNl (f);
  608.     WriteS (f, '# include "System.h"'); WriteNl (f);
  609.     WriteS (f, '# include "General.h"'); WriteNl (f);
  610.     WriteS (f, '# include "Memory.h"'); WriteNl (f);
  611.     WriteS (f, '# include "DynArray.h"'); WriteNl (f);
  612.     WriteS (f, '# include "StringMem.h"'); WriteNl (f);
  613.     WriteS (f, '# include "Idents.h"'); WriteNl (f);
  614.     WriteS (f, '# include "Sets.h"'); WriteNl (f);
  615.     WriteS (f, '# include "Positions.h"'); WriteNl (f);
  616.     WriteS (f, "# endif"); WriteNl (f);
  617.     WriteNl (f);
  618.     WriteLine (TreeCodes^.Codes.GlobalLine);
  619.     WriteText (f, TreeCodes^.Codes.Global);
  620.     Node := Modules;
  621.     WHILE Node^.Kind = Tree.Module DO
  622.        WriteLine (Node^.Module.TreeCodes^.Codes.GlobalLine);
  623.        WriteText (f, Node^.Module.TreeCodes^.Codes.Global);
  624.        Node := Node^.Module.Next;
  625.     END;
  626.     WriteLine (TreeCodes^.Codes.LocalLine);
  627.     WriteText (f, TreeCodes^.Codes.Local);
  628.     Node := Modules;
  629.     WHILE Node^.Kind = Tree.Module DO
  630.        WriteLine (Node^.Module.TreeCodes^.Codes.LocalLine);
  631.        WriteText (f, Node^.Module.TreeCodes^.Codes.Local);
  632.        Node := Node^.Module.Next;
  633.     END;
  634.     WriteS (f, "# ifdef getchar"); WriteNl (f);
  635.     WriteS (f, "# undef getchar"); WriteNl (f);
  636.     WriteS (f, "# endif"); WriteNl (f);
  637.     WriteS (f, "# ifdef putchar"); WriteNl (f);
  638.     WriteS (f, "# undef putchar"); WriteNl (f);
  639.     WriteS (f, "# endif"); WriteNl (f);
  640.     WriteS (f, '# include "yy'); WI (iModule); WriteS (f, '.w"'); WriteNl (f);
  641.     WriteNl (f);
  642.       IF NOT IsElement (ORD ('<'), Options) THEN
  643.     WriteS (f, "static void yyExit () { Exit (1); }"); WriteNl (f);
  644.     WriteNl (f);
  645.     WriteS (f, "void (* "); WI (iMain); WriteS (f, "_Exit) () = yyExit;"); WriteNl (f);
  646.     WriteNl (f);
  647.     WriteS (f, "# define yyBlockSize 20480"); WriteNl (f);
  648.     WriteNl (f);
  649.     WriteS (f, "typedef struct yysBlock {"); WriteNl (f);
  650.     WriteS (f, " char yyBlock [yyBlockSize];"); WriteNl (f);
  651.     WriteS (f, " struct yysBlock * yySuccessor;"); WriteNl (f);
  652.     WriteS (f, "} yytBlock, * yytBlockPtr;"); WriteNl (f);
  653.     WriteNl (f);
  654.     WI (itTree); WriteS (f, " "); WI (iMain); WriteS (f, "Root;"); WriteNl (f);
  655.     WriteS (f, "unsigned long "); WI (iMain); WriteS (f, "_HeapUsed = 0;"); WriteNl (f);
  656.     WriteNl (f);
  657.     WriteS (f, "static yytBlockPtr yyBlockList    = (yytBlockPtr) "); WI (iNoTree); WriteS (f, ";"); WriteNl (f);
  658.     WriteS (f, "char * "); WI (iMain); WriteS (f, "_PoolFreePtr    = (char *) "); WI (iNoTree); WriteS (f, ";"); WriteNl (f);
  659.     WriteS (f, "char * "); WI (iMain); WriteS (f, "_PoolMaxPtr    = (char *) "); WI (iNoTree); WriteS (f, ";"); WriteNl (f);
  660.     WriteS (f, "static unsigned short yyMaxSize    = 0;"); WriteNl (f);
  661.     WriteS (f, "unsigned short "); WI (iMain); WriteS (f, "_NodeSize ["); WN (ClassCount); WriteS (f, " + 1] = { 0,"); WriteNl (f);
  662.     ForallClasses (Classes, InitNodeSize);
  663.     WriteS (f, "};"); WriteNl (f);
  664.     WriteS (f, "char * "); WI (iMain); WriteS (f, "_NodeName ["); WN (ClassCount); WriteS (f, " + 1] = {"); WriteNl (f);
  665.     WriteS (f, ' "'); WI (iNoTree); WriteS (f, '",'); WriteNl (f);
  666.     ForallClasses (Classes, InitNodeName);
  667.     WriteS (f, "};"); WriteNl (f);
  668.     WriteS (f, "static "); WI (iMain); WriteS (f, "_tKind yyTypeRange ["); WN (ClassCount); WriteS (f, " + 1] = { 0,"); WriteNl (f);
  669.     ForallClasses (Classes, InitTypeRange);
  670.     WriteS (f, "};"); WriteNl (f);
  671.     WriteNl (f);
  672.     WI (itTree); WriteS (f, " "); WI (iMain); WriteS (f, "_Alloc ()"); WriteNl (f);
  673.     WriteS (f, "{"); WriteNl (f);
  674.     WriteS (f, " register yytBlockPtr yyBlockPtr = yyBlockList;"); WriteNl (f);
  675.     WriteS (f, " register int i;"); WriteNl (f);
  676.     WriteNl (f);
  677.     WriteS (f, " if (yyMaxSize == 0)"); WriteNl (f);
  678.     WriteS (f, "  for (i = 1; i <= "); WN (ClassCount); WriteS (f, "; i ++) {"); WriteNl (f);
  679.     WriteS (f, "   "); WI (iMain); WriteS (f, "_NodeSize [i] = ("); WI (iMain); WriteS (f, "_NodeSize [i] + yyMaxAlign - 1) & yyAlignMasks [yyMaxAlign];"); WriteNl (f);
  680.     WriteS (f, "   yyMaxSize = Max ("); WI (iMain); WriteS (f, "_NodeSize [i], yyMaxSize);"); WriteNl (f);
  681.     WriteS (f, "  }"); WriteNl (f);
  682.     WriteS (f, " yyBlockList = (yytBlockPtr) Alloc (sizeof (yytBlock));"); WriteNl (f);
  683.     WriteS (f, " yyBlockList->yySuccessor = yyBlockPtr;"); WriteNl (f);
  684.     WriteS (f, " "); WI (iMain); WriteS (f, "_PoolFreePtr = yyBlockList->yyBlock;"); WriteNl (f);
  685.     WriteS (f, " "); WI (iMain); WriteS (f, "_PoolMaxPtr = "); WI (iMain); WriteS (f, "_PoolFreePtr + yyBlockSize - yyMaxSize + 1;"); WriteNl (f);
  686.     WriteS (f, " "); WI (iMain); WriteS (f, "_HeapUsed += yyBlockSize;"); WriteNl (f);
  687.     WriteS (f, " return ("); WI (itTree); WriteS (f, ") "); WI (iMain); WriteS (f, "_PoolFreePtr;"); WriteNl (f);
  688.     WriteS (f, "}"); WriteNl (f);
  689.     WriteNl (f);
  690.     WI (itTree); WriteS (f, " Make"); WI (iMain); WriteNl (f);
  691.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  692.     WriteS (f, " ("); WI (iMain); WriteS (f, "_tKind yyKind)"); WriteNl (f);
  693.     WriteS (f, "# else"); WriteNl (f);
  694.     WriteS (f, " (yyKind) "); WI (iMain); WriteS (f, "_tKind yyKind;"); WriteNl (f);
  695.     WriteS (f, "# endif"); WriteNl (f);
  696.     WriteS (f, "{"); WriteNl (f);
  697.     WriteS (f, " register "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  698.     WriteS (f, " yyALLOC (yyt, "); WI (iMain); WriteS (f, "_NodeSize [yyKind])"); WriteNl (f);
  699.     WriteS (f, " yyt->Kind = yyKind;"); WriteNl (f);
  700.     WriteS (f, " yyt->yyHead.yyMark = 0;"); WriteNl (f);
  701.       IF IsElement (ORD ('L'), Options) THEN
  702.     WriteS (f, " yyt->yyHead.yyParent = "); WI (iNoTree); WriteS (f, ";"); WriteNl (f);
  703.       END;
  704.     WriteS (f, " return yyt;"); WriteNl (f);
  705.     WriteS (f, "}"); WriteNl (f);
  706.     WriteNl (f);
  707.     WriteS (f, "bool "); WI (iMain); WriteS (f, "_IsType"); WriteNl (f);
  708.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  709.     WriteS (f, " (register "); WI (itTree); WriteS (f, " yyt, register "); WI (iMain); WriteS (f, "_tKind yyKind)"); WriteNl (f);
  710.     WriteS (f, "# else"); WriteNl (f);
  711.     WriteS (f, " (yyt, yyKind) register "); WI (itTree); WriteS (f, " yyt; register "); WI (iMain); WriteS (f, "_tKind yyKind;"); WriteNl (f);
  712.     WriteS (f, "# endif"); WriteNl (f);
  713.     WriteS (f, "{"); WriteNl (f);
  714.     WriteS (f, ' return yyt != '); WI (iNoTree); WriteS (f, " && yyKind <= yyt->Kind && yyt->Kind <= yyTypeRange [yyKind];"); WriteNl (f);
  715.     WriteS (f, "}"); WriteNl (f);
  716.     WriteNl (f);
  717.       END;
  718.       IF IsElement (ORD ('n'), Options) THEN
  719.     ForallClasses (Classes, ProcedureBodyn);
  720.       END;
  721.     WriteNl (f);
  722.       IF IsElement (ORD ('m'), Options) THEN
  723.     ForallClasses (Classes, ProcedureBodym);
  724.       END;
  725.     TreeIO (t);
  726.       IF IsElement (ORD ('f'), Options) THEN
  727.     WriteS (f, "static "); WI (itTree); WriteS (f, " yyChild;"); WriteNl (f);
  728.     WriteNl (f);
  729.     WriteS (f, "static void yyRelease"); WI (iModule); WriteNl (f);
  730.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  731.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  732.     WriteS (f, "# else"); WriteNl (f);
  733.     WriteS (f, " (yyt) "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  734.     WriteS (f, "# endif"); WriteNl (f);
  735.     WriteS (f, "{"); WriteNl (f);
  736.     WriteS (f, " if (yyt == "); WI (iNoTree); WriteS (f, ") return;"); WriteNl (f);
  737.     WriteS (f, " switch (yyt->Kind) {"); WriteNl (f);
  738.     ForallClasses (Classes, ReleaseAttributes1);
  739.     WriteS (f, " default: ;"); WriteNl (f);
  740.     WriteS (f, " }"); WriteNl (f);
  741.     WriteNl (f);
  742.     WriteS (f, " if (-- yyt->yyHead.yyMark == 0) {"); WriteNl (f);
  743.     WriteS (f, "  switch (yyt->Kind) {"); WriteNl (f);
  744.     ForallClasses (Classes, ReleaseAttributes2);
  745.     WriteS (f, "  default: ;"); WriteNl (f);
  746.     WriteS (f, "  }"); WriteNl (f);
  747.     WriteS (f, "  yyFREE (yyt, "); WI (iMain); WriteS (f, "_NodeSize [yyt->Kind])"); WriteNl (f);
  748.     WriteS (f, " }"); WriteNl (f);
  749.     WriteS (f, "}"); WriteNl (f);
  750.     WriteNl (f);
  751.     WriteS (f, "void Release"); WI (iModule); WriteNl (f);
  752.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  753.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  754.     WriteS (f, "# else"); WriteNl (f);
  755.     WriteS (f, " (yyt) "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  756.     WriteS (f, "# endif"); WriteNl (f);
  757.     WriteS (f, "{"); WriteNl (f);
  758.     WriteS (f, " yyMark (yyt);"); WriteNl (f);
  759.     WriteS (f, " yyRelease"); WI (iModule); WriteS (f, " (yyt);"); WriteNl (f);
  760.     WriteS (f, "}"); WriteNl (f);
  761.     WriteNl (f);
  762.       END;
  763.       IF IsElement (ORD ('F'), Options) AND NOT IsElement (ORD ('<'), Options) THEN
  764.     WriteS (f, "void Release"); WI (iModule); WriteS (f, "Module ()"); WriteNl (f);
  765.     WriteS (f, "{"); WriteNl (f);
  766.     WriteS (f, " yytBlockPtr yyBlockPtr;"); WriteNl (f);
  767.     WriteS (f, ' while (yyBlockList != (yytBlockPtr) '); WI (iNoTree); WriteS (f, ') {'); WriteNl (f);
  768.     WriteS (f, "  yyBlockPtr = yyBlockList;"); WriteNl (f);
  769.     WriteS (f, "  yyBlockList = yyBlockList->yySuccessor;"); WriteNl (f);
  770.     WriteS (f, "  Free (sizeof (yytBlock), (char *) yyBlockPtr);"); WriteNl (f);
  771.     WriteS (f, " }"); WriteNl (f);
  772.     WriteS (f, " "); WI (iMain); WriteS (f, "_PoolFreePtr = (char *) "); WI (iNoTree); WriteS (f, ";"); WriteNl (f);
  773.     WriteS (f, " "); WI (iMain); WriteS (f, "_PoolMaxPtr = (char *) "); WI (iNoTree); WriteS (f, ";"); WriteNl (f);
  774.     WriteS (f, " "); WI (iMain); WriteS (f, "_HeapUsed = 0;"); WriteNl (f);
  775.     WriteS (f, "}"); WriteNl (f);
  776.     WriteNl (f);
  777.       END;
  778.       IF IsElement (ORD ('t'), Options) OR
  779.          IsElement (ORD ('b'), Options) THEN
  780.     WriteS (f, "static "); WI (iMain); WriteS (f, "_tProcTree yyProc;"); WriteNl (f);
  781.     WriteNl (f);
  782.       END;
  783.       IF IsElement (ORD ('t'), Options) THEN
  784.     WriteS (f, "static void yyTraverse"); WI (iModule); WriteS (f, "TD"); WriteNl (f);
  785.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  786.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  787.     WriteS (f, "# else"); WriteNl (f);
  788.     WriteS (f, " (yyt) "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  789.     WriteS (f, "# endif"); WriteNl (f);
  790.     WriteS (f, "{"); WriteNl (f);
  791.     WriteS (f, " for (;;) {"); WriteNl (f);
  792.     WriteS (f, "  if (yyt == "); WI (iNoTree); WriteS (f, " || yyt->yyHead.yyMark == 0) return;"); WriteNl (f);
  793.     WriteS (f, "  yyt->yyHead.yyMark = 0;"); WriteNl (f);
  794.     WriteS (f, "  yyProc (yyt);"); WriteNl (f);
  795.     WriteNl (f);
  796.     WriteS (f, "  switch (yyt->Kind) {"); WriteNl (f);
  797.     ForallClasses (Classes, TraverseTD);
  798.     WriteS (f, "  default: return;"); WriteNl (f);
  799.     WriteS (f, "  }"); WriteNl (f);
  800.     WriteS (f, " }"); WriteNl (f);
  801.     WriteS (f, "}"); WriteNl (f);
  802.     WriteNl (f);
  803.     WriteS (f, "void Traverse"); WI (iModule); WriteS (f, "TD"); WriteNl (f);
  804.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  805.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt, "); WI (iMain); WriteS (f, "_tProcTree yyyProc)"); WriteNl (f);
  806.     WriteS (f, "# else"); WriteNl (f);
  807.     WriteS (f, " (yyt, yyyProc) "); WI (itTree); WriteS (f, " yyt; "); WI (iMain); WriteS (f, "_tProcTree yyyProc;"); WriteNl (f);
  808.     WriteS (f, "# endif"); WriteNl (f);
  809.     WriteS (f, "{"); WriteNl (f);
  810.     WriteS (f, " yyMark (yyt);"); WriteNl (f);
  811.     WriteS (f, " yyProc = yyyProc;"); WriteNl (f);
  812.     WriteS (f, " yyTraverse"); WI (iModule); WriteS (f, "TD (yyt);"); WriteNl (f);
  813.     WriteS (f, "}"); WriteNl (f);
  814.     WriteNl (f);
  815.       END;
  816.       IF IsElement (ORD ('b'), Options) THEN
  817.     WriteS (f, "static void yyTraverse"); WI (iModule); WriteS (f, "BU"); WriteNl (f);
  818.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  819.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  820.     WriteS (f, "# else"); WriteNl (f);
  821.     WriteS (f, " (yyt) "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  822.     WriteS (f, "# endif"); WriteNl (f);
  823.     WriteS (f, "{"); WriteNl (f);
  824.     WriteS (f, " if (yyt == "); WI (iNoTree); WriteS (f, " || yyt->yyHead.yyMark == 0) return;"); WriteNl (f);
  825.     WriteS (f, " yyt->yyHead.yyMark = 0;"); WriteNl (f);
  826.     WriteNl (f);
  827.     WriteS (f, " switch (yyt->Kind) {"); WriteNl (f);
  828.     ForallClasses (Classes, TraverseBU);
  829.     WriteS (f, " default: ;"); WriteNl (f);
  830.     WriteS (f, " }"); WriteNl (f);
  831.     WriteS (f, " yyProc (yyt);"); WriteNl (f);
  832.     WriteS (f, "}"); WriteNl (f);
  833.     WriteNl (f);
  834.     WriteS (f, "void Traverse"); WI (iModule); WriteS (f, "BU"); WriteNl (f);
  835.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  836.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt, "); WI (iMain); WriteS (f, "_tProcTree yyyProc)"); WriteNl (f);
  837.     WriteS (f, "# else"); WriteNl (f);
  838.     WriteS (f, " (yyt, yyyProc) "); WI (itTree); WriteS (f, " yyt; "); WI (iMain); WriteS (f, "_tProcTree yyyProc;"); WriteNl (f);
  839.     WriteS (f, "# endif"); WriteNl (f);
  840.     WriteS (f, "{"); WriteNl (f);
  841.     WriteS (f, " yyMark (yyt);"); WriteNl (f);
  842.     WriteS (f, " yyProc = yyyProc;"); WriteNl (f);
  843.     WriteS (f, " yyTraverse"); WI (iModule); WriteS (f, "BU (yyt);"); WriteNl (f);
  844.     WriteS (f, "}"); WriteNl (f);
  845.     WriteNl (f);
  846.       END;
  847.       IF IsElement (ORD ('R'), Options) THEN
  848.     WI (itTree); WriteS (f, " Reverse"); WI (iModule); WriteNl (f);
  849.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  850.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyOld)"); WriteNl (f);
  851.     WriteS (f, "# else"); WriteNl (f);
  852.     WriteS (f, " (yyOld) "); WI (itTree); WriteS (f, " yyOld;"); WriteNl (f);
  853.     WriteS (f, "# endif"); WriteNl (f);
  854.     WriteS (f, "{"); WriteNl (f);
  855.     WriteS (f, " register "); WI (itTree); WriteS (f, " yyNew, yyNext, yyTail;"); WriteNl (f);
  856.     WriteS (f, " yyNew = yyOld;"); WriteNl (f);
  857.     WriteS (f, " yyTail = yyOld;"); WriteNl (f);
  858.     WriteS (f, " for (;;) {"); WriteNl (f);
  859.     WriteS (f, "  switch (yyOld->Kind) {"); WriteNl (f);
  860.     ForallClasses (Classes, Reverse1);
  861.     WriteS (f, "  default: goto yyExit;"); WriteNl (f);
  862.     WriteS (f, "  }"); WriteNl (f);
  863.     WriteS (f, "  yyNew = yyOld;"); WriteNl (f);
  864.     WriteS (f, "  yyOld = yyNext;"); WriteNl (f);
  865.     WriteS (f, " }"); WriteNl (f);
  866.     WriteS (f, "yyExit:"); WriteNl (f);
  867.     WriteS (f, " switch (yyTail->Kind) {"); WriteNl (f);
  868.     ForallClasses (Classes, Reverse2);
  869.     WriteS (f, " default: ;"); WriteNl (f);
  870.     WriteS (f, " }"); WriteNl (f);
  871.     WriteS (f, " return yyNew;"); WriteNl (f);
  872.     WriteS (f, "}"); WriteNl (f);
  873.     WriteNl (f);
  874.       END;
  875.       IF IsElement (ORD ('y'), Options) THEN
  876.         WriteS (f, "# define yyInitOldToNewStoreSize 32"); WriteNl (f);
  877.     WriteNl (f);
  878.     WriteS (f, "typedef struct { "); WI (itTree); WriteS (f, " yyOld, yyNew; } yytOldToNew;"); WriteNl (f);
  879.         WriteS (f, "static unsigned long yyOldToNewStoreSize = yyInitOldToNewStoreSize;"); WriteNl (f);
  880.         WriteS (f, "static yytOldToNew yyOldToNewStore [yyInitOldToNewStoreSize];"); WriteNl (f);
  881.         WriteS (f, "static yytOldToNew * yyOldToNewStorePtr = yyOldToNewStore;"); WriteNl (f);
  882.     WriteS (f, "static int yyOldToNewCount;"); WriteNl (f);
  883.     WriteNl (f);
  884.     WriteS (f, "static void yyStoreOldToNew"); WriteNl (f);
  885.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  886.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyOld, "); WI (itTree); WriteS (f, " yyNew)"); WriteNl (f);
  887.     WriteS (f, "# else"); WriteNl (f);
  888.     WriteS (f, " (yyOld, yyNew) "); WI (itTree); WriteS (f, " yyOld, yyNew;"); WriteNl (f);
  889.     WriteS (f, "# endif"); WriteNl (f);
  890.     WriteS (f, "{"); WriteNl (f);
  891.     WriteS (f, " if (++ yyOldToNewCount == yyOldToNewStoreSize)"); WriteNl (f);
  892.     WriteS (f, "  ExtendArray ((char * *) & yyOldToNewStorePtr, & yyOldToNewStoreSize, sizeof (yytOldToNew));"); WriteNl (f);
  893.     WriteS (f, " yyOldToNewStorePtr [yyOldToNewCount].yyOld = yyOld;"); WriteNl (f);
  894.     WriteS (f, " yyOldToNewStorePtr [yyOldToNewCount].yyNew = yyNew;"); WriteNl (f);
  895.     WriteS (f, "}"); WriteNl (f);
  896.     WriteNl (f);
  897.     WriteS (f, "static "); WI (itTree); WriteS (f, " yyMapOldToNew"); WriteNl (f);
  898.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  899.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyOld)"); WriteNl (f);
  900.     WriteS (f, "# else"); WriteNl (f);
  901.     WriteS (f, " (yyOld) "); WI (itTree); WriteS (f, " yyOld;"); WriteNl (f);
  902.     WriteS (f, "# endif"); WriteNl (f);
  903.     WriteS (f, "{"); WriteNl (f);
  904.     WriteS (f, " register int yyi;"); WriteNl (f);
  905.     WriteS (f, " for (yyi = 1; yyi <= yyOldToNewCount; yyi ++)"); WriteNl (f);
  906.     WriteS (f, "  if (yyOldToNewStorePtr [yyi].yyOld == yyOld) return yyOldToNewStorePtr [yyi].yyNew;"); WriteNl (f);
  907.     WriteS (f, "}"); WriteNl (f);
  908.     WriteNl (f);
  909.     WriteS (f, "static "); WI (itTree); WriteS (f, " yyCopy"); WI (iModule); WriteNl (f);
  910.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  911.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt, yyPtrtTree yyNew)"); WriteNl (f);
  912.     WriteS (f, "# else"); WriteNl (f);
  913.     WriteS (f, " (yyt, yyNew) "); WI (itTree); WriteS (f, " yyt; yyPtrtTree yyNew;"); WriteNl (f);
  914.     WriteS (f, "# endif"); WriteNl (f);
  915.     WriteS (f, "{"); WriteNl (f);
  916.     WriteS (f, " for (;;) {"); WriteNl (f);
  917.     WriteS (f, "  if (yyt == "); WI (iNoTree); WriteS (f, ") { * yyNew = "); WI (iNoTree); WriteS (f, "; return; }"); WriteNl (f);
  918.     WriteS (f, "  if (yyt->yyHead.yyMark == 0) { * yyNew = yyMapOldToNew (yyt); return; }"); WriteNl (f);
  919.     WriteS (f, "  yyALLOC (* yyNew, "); WI (iMain); WriteS (f, "_NodeSize [yyt->Kind])"); WriteNl (f);
  920.     WriteS (f, "  if (yyt->yyHead.yyMark > 1) { yyStoreOldToNew (yyt, * yyNew); }"); WriteNl (f);
  921.     WriteS (f, "  yyt->yyHead.yyMark = 0;"); WriteNl (f);
  922.     WriteNl (f);
  923.     WriteS (f, "  switch (yyt->Kind) {"); WriteNl (f);
  924.     ForallClasses (Classes, Copy);
  925.     WriteS (f, "  default: ;"); WriteNl (f);
  926.     WriteS (f, "  }"); WriteNl (f);
  927.     WriteS (f, " }"); WriteNl (f);
  928.     WriteS (f, "}"); WriteNl (f);
  929.     WriteNl (f);
  930.     WI (itTree); WriteS (f, " Copy"); WI (iModule); WriteNl (f);
  931.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  932.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  933.     WriteS (f, "# else"); WriteNl (f);
  934.     WriteS (f, " (yyt) "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  935.     WriteS (f, "# endif"); WriteNl (f);
  936.     WriteS (f, "{"); WriteNl (f);
  937.     WriteS (f, " "); WI (itTree); WriteS (f, " yyNew;"); WriteNl (f);
  938.     WriteS (f, " yyMark (yyt);"); WriteNl (f);
  939.     WriteS (f, " yyOldToNewCount = 0;"); WriteNl (f);
  940.     WriteS (f, " yyCopy"); WI (iModule); WriteS (f, " (yyt, & yyNew);"); WriteNl (f);
  941.     WriteS (f, " return yyNew;"); WriteNl (f);
  942.     WriteS (f, "}"); WriteNl (f);
  943.     WriteNl (f);
  944.       END;
  945.       IF IsElement (ORD ('k'), Options) THEN
  946.     WriteS (f, "static bool yyCheck"); WI (iModule); WriteS (f, " ARGS(("); WI (itTree); WriteS (f, " yyt));"); WriteNl (f);
  947.     WriteNl (f);
  948.     WriteS (f, "bool Check"); WI (iModule); WriteNl (f);
  949.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  950.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  951.     WriteS (f, "# else"); WriteNl (f);
  952.     WriteS (f, " (yyt) "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  953.     WriteS (f, "# endif"); WriteNl (f);
  954.     WriteS (f, "{"); WriteNl (f);
  955.     WriteS (f, " yyMark (yyt);"); WriteNl (f);
  956.     WriteS (f, " return yyCheck"); WI (iModule); WriteS (f, " (yyt);"); WriteNl (f);
  957.     WriteS (f, "}"); WriteNl (f);
  958.     WriteNl (f);
  959.     WriteS (f, "static bool yyCheckChild"); WriteNl (f);
  960.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  961.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyParent, "); WI (itTree); WriteS (f, " yyyChild, "); WI (iMain); WriteS (f, "_tKind yyType, char * yySelector)"); WriteNl (f);
  962.     WriteS (f, "# else"); WriteNl (f);
  963.     WriteS (f, " (yyParent, yyyChild, yyType, yySelector)"); WriteNl (f);
  964.     WriteS (f, " "); WI (itTree); WriteS (f, " yyParent, yyyChild;"); WriteNl (f);
  965.     WriteS (f, " "); WI (iMain); WriteS (f, "_tKind yyType;"); WriteNl (f);
  966.     WriteS (f, " char * yySelector;"); WriteNl (f);
  967.     WriteS (f, "# endif"); WriteNl (f);
  968.     WriteS (f, "{"); WriteNl (f);
  969.     WriteS (f, " bool yySuccess = "); WI (iMain); WriteS (f, "_IsType (yyyChild, yyType);"); WriteNl (f);
  970.     WriteS (f, ' if (! yySuccess) {'); WriteNl (f);
  971.     WriteS (f, '  (void) fputs ("CheckTree: parent = ", stderr);'); WriteNl (f);
  972.     WriteS (f, "  Write"); WI (iModule); WriteS (f, "Node (stderr, yyParent);"); WriteNl (f);
  973.     WriteS (f, '  (void) fprintf (stderr, "\nselector: %s child = ", yySelector);'); WriteNl (f);
  974.     WriteS (f, "  Write"); WI (iModule); WriteS (f, "Node (stderr, yyyChild);"); WriteNl (f);
  975.     WriteS (f, "  (void) fputc ('\n', stderr);"); WriteNl (f);
  976.     WriteS (f, " }"); WriteNl (f);
  977.     WriteS (f, " return yyCheck"); WI (iModule); WriteS (f, " (yyyChild) && yySuccess;"); WriteNl (f);
  978.     WriteS (f, "}"); WriteNl (f);
  979.     WriteNl (f);
  980.     WriteS (f, "static bool yyCheck"); WI (iModule); WriteNl (f);
  981.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  982.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  983.     WriteS (f, "# else"); WriteNl (f);
  984.     WriteS (f, " (yyt) "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  985.     WriteS (f, "# endif"); WriteNl (f);
  986.     WriteS (f, "{"); WriteNl (f);
  987.     WriteS (f, " bool yyResult;"); WriteNl (f);
  988.     WriteS (f, " if (yyt == "); WI (iNoTree); WriteS (f, ") return false;"); WriteNl (f);
  989.     WriteS (f, " else if (yyt->yyHead.yyMark == 0) return true;"); WriteNl (f);
  990.     WriteS (f, " yyt->yyHead.yyMark = 0;"); WriteNl (f);
  991.     WriteNl (f);
  992.     WriteS (f, " yyResult = true;"); WriteNl (f);
  993.     WriteS (f, " switch (yyt->Kind) {"); WriteNl (f);
  994.     ForallClasses (Classes, CheckAttributes);
  995.     WriteS (f, " default: ;"); WriteNl (f);
  996.     WriteS (f, " }"); WriteNl (f);
  997.     WriteS (f, " return yyResult;"); WriteNl (f);
  998.     WriteS (f, "}"); WriteNl (f);
  999.     WriteNl (f);
  1000.       END;
  1001.       IF IsElement (ORD ('q'), Options) THEN
  1002.     WriteS (f, "# define yyyWrite    1"); WriteNl (f);
  1003.     WriteS (f, "# define yyyRead    2"); WriteNl (f);
  1004.     WriteS (f, "# define yyyQuit    3"); WriteNl (f);
  1005.     WriteNl (f);
  1006.     WriteS (f, "static char yyyString [32], yyCh;"); WriteNl (f);
  1007.     WriteS (f, "static int yyLength, yyState;"); WriteNl (f);
  1008.     WriteNl (f);
  1009.     WriteS (f, "static bool yyyIsEqual"); WriteNl (f);
  1010.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  1011.     WriteS (f, " (char * yya)"); WriteNl (f);
  1012.     WriteS (f, "# else"); WriteNl (f);
  1013.     WriteS (f, " (yya) char * yya;"); WriteNl (f);
  1014.     WriteS (f, "# endif"); WriteNl (f);
  1015.     WriteS (f, "{"); WriteNl (f);
  1016.     WriteS (f, " register int yyi;"); WriteNl (f);
  1017.     WriteS (f, " if (yyLength >= 0 && yyyString [yyLength] == ' ') {"); WriteNl (f);
  1018.     WriteS (f, '  if (yyLength != strlen (yya)) return false;'); WriteNl (f);
  1019.     WriteS (f, "  for (yyi = 0; yyi < yyLength; yyi ++)"); WriteNl (f);
  1020.     WriteS (f, '   if (yyyString [yyi] != yya [yyi]) return false;'); WriteNl (f);
  1021.     WriteS (f, " } else {"); WriteNl (f);
  1022.     WriteS (f, "  if (yyLength >= strlen (yya)) return false;"); WriteNl (f);
  1023.     WriteS (f, "  for (yyi = 0; yyi <= yyLength; yyi ++)"); WriteNl (f);
  1024.     WriteS (f, '   if (yyyString [yyi] != yya [yyi]) return false;'); WriteNl (f);
  1025.     WriteS (f, " }"); WriteNl (f);
  1026.     WriteS (f, " return true;"); WriteNl (f);
  1027.     WriteS (f, "}"); WriteNl (f);
  1028.     WriteNl (f);
  1029.     WriteS (f, "void Query"); WI (iModule); WriteNl (f);
  1030.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  1031.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  1032.     WriteS (f, "# else"); WriteNl (f);
  1033.     WriteS (f, " (yyt) "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  1034.     WriteS (f, "# endif"); WriteNl (f);
  1035.     WriteS (f, "{"); WriteNl (f);
  1036.     WriteS (f, " yyState = yyyWrite;"); WriteNl (f);
  1037.     WriteS (f, " for (;;) {"); WriteNl (f);
  1038.     WriteS (f, "  switch (yyState) {"); WriteNl (f);
  1039.     WriteS (f, "  case yyyQuit : return;"); WriteNl (f);
  1040.     WriteS (f, "  case yyyWrite: Write"); WI (iModule); WriteS (f, "Node (stdout, yyt); yyState = yyyRead;"); WriteNl (f);
  1041.     WriteS (f, '  case yyyRead : (void) printf ("? "); yyLength = -1; yyCh = getc (stdin);'); WriteNl (f);
  1042.     WriteS (f, '   while (yyCh != ');WriteS (f, "'\n' && yyCh > 0)"); WriteNl (f);
  1043.     WriteS (f, "    { yyyString [++ yyLength] = yyCh; yyCh = getc (stdin); }"); WriteNl (f);
  1044.     WriteS (f, '   if (yyCh < 0) { (void) fputs ("QueryTree: eof reached\n", stderr);'); WriteNl (f);
  1045.     WriteS (f, "    yyState = yyyQuit; return; }"); WriteNl (f);
  1046.     WriteS (f, '   if      (yyyIsEqual ("parent")) { yyState = yyyWrite; return; }'); WriteNl (f);
  1047.     WriteS (f, '   else if (yyyIsEqual ("quit"  )) { yyState = yyyQuit ; return; }'); WriteNl (f);
  1048.     WriteS (f, '   else if (yyt != '); WI (iNoTree); WriteS (f, ") {"); WriteNl (f);
  1049.     WriteS (f, "    switch (yyt->Kind) {"); WriteNl (f);
  1050.     ForallClasses (Classes, QueryAttributes);
  1051.     WriteS (f, "    default: ;"); WriteNl (f);
  1052.     WriteS (f, "    }"); WriteNl (f);
  1053.     WriteS (f, "   }"); WriteNl (f);
  1054.     WriteS (f, "  }"); WriteNl (f);
  1055.     WriteS (f, " }"); WriteNl (f);
  1056.     WriteS (f, "}"); WriteNl (f);
  1057.     WriteNl (f);
  1058.       END;
  1059.       IF IsElement (ORD ('='), Options) THEN
  1060.     WriteS (f, "bool IsEqual"); WI (iModule); WriteNl (f);
  1061.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  1062.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt1, "); WI (itTree); WriteS (f, " yyt2)"); WriteNl (f);
  1063.     WriteS (f, "# else"); WriteNl (f);
  1064.     WriteS (f, " (yyt1, yyt2) "); WI (itTree); WriteS (f, " yyt1, yyt2;"); WriteNl (f);
  1065.     WriteS (f, "# endif"); WriteNl (f);
  1066.     WriteS (f, "{"); WriteNl (f);
  1067.     WriteS (f, " if (yyt1 == yyt2) return true;"); WriteNl (f);
  1068.     WriteS (f, " if (yyt1 == "); WI (iNoTree); WriteS (f, " || yyt2 == "); WI (iNoTree); WriteS (f, ' || yyt1->Kind != yyt2->Kind) return false;'); WriteNl (f);
  1069.     WriteS (f, " switch (yyt1->Kind) {"); WriteNl (f);
  1070.     ForallClasses (Classes, IsEqualAttributes);
  1071.     WriteS (f, " default: return true;"); WriteNl (f);
  1072.     WriteS (f, " }"); WriteNl (f);
  1073.     WriteS (f, "}"); WriteNl (f);
  1074.     WriteNl (f);
  1075.       END;
  1076.       IF IsElement (ORD ('L'), Options) THEN
  1077.     MaxBit := 0;
  1078.     ForallClasses (Classes, CompMaxBit);
  1079.     WriteS (f, "void Init"); WI (iModule); WriteNl (f);
  1080.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  1081.     WriteS (f, " (register "); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  1082.     WriteS (f, "# else"); WriteNl (f);
  1083.     WriteS (f, " (yyt) register "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  1084.     WriteS (f, "# endif"); WriteNl (f);
  1085.     WriteS (f, "{"); WriteNl (f);
  1086.     WriteS (f, " register "); WI (itTree); WriteS (f, " yyr;"); WriteNl (f);
  1087.     WriteS (f, " for (;;) {"); WriteNl (f);
  1088.     FOR i := 0 TO (MaxBit - 1) DIV BSS DO
  1089.        WriteS (f, "  yyt->yyHead.yyIsComp"); WN (i); WriteS (f, " = 0;"); WriteNl (f);
  1090.       IF IsElement (ORD ('5'), Options) THEN
  1091.        WriteS (f, "  yyt->yyHead.yyIsDone"); WN (i); WriteS (f, " = 0;"); WriteNl (f);
  1092.       END;
  1093.     END;
  1094.     WriteS (f, "  switch (yyt->Kind) {"); WriteNl (f);
  1095.     ForallClasses (Classes, InitAttributes);
  1096.     WriteS (f, "  default: return;"); WriteNl (f);
  1097.     WriteS (f, "  }"); WriteNl (f);
  1098.     WriteS (f, " }"); WriteNl (f);
  1099.     WriteS (f, "}"); WriteNl (f);
  1100.     WriteNl (f);
  1101.       END;
  1102.     WriteS (f, "void Begin"); WI (iModule); WriteS (f, " ()"); WriteNl (f);
  1103.     WriteS (f, "{"); WriteNl (f);
  1104.     WriteLine (TreeCodes^.Codes.BeginLine);
  1105.     WriteText (f, TreeCodes^.Codes.Begin);
  1106.     Node := Modules;
  1107.     WHILE Node^.Kind = Tree.Module DO
  1108.        WriteLine (Node^.Module.TreeCodes^.Codes.BeginLine);
  1109.        WriteText (f, Node^.Module.TreeCodes^.Codes.Begin);
  1110.        Node := Node^.Module.Next;
  1111.     END;
  1112.     WriteS (f, "}"); WriteNl (f);
  1113.     WriteNl (f);
  1114.     WriteS (f, "void Close"); WI (iModule); WriteS (f, " ()"); WriteNl (f);
  1115.     WriteS (f, "{"); WriteNl (f);
  1116.     WriteLine (TreeCodes^.Codes.CloseLine);
  1117.     WriteText (f, TreeCodes^.Codes.Close);
  1118.     Node := Modules;
  1119.     WHILE Node^.Kind = Tree.Module DO
  1120.        WriteLine (Node^.Module.TreeCodes^.Codes.CloseLine);
  1121.        WriteText (f, Node^.Module.TreeCodes^.Codes.Close);
  1122.        Node := Node^.Module.Next;
  1123.     END;
  1124.     WriteS (f, "}"); WriteNl (f);
  1125. ;
  1126.       RETURN;
  1127.      END;
  1128.  
  1129.   END;
  1130.  END TreeImplC;
  1131.  
  1132. PROCEDURE ProcedureBodyn (t: Tree.tTree);
  1133.  VAR yyTempo: RECORD CASE : INTEGER OF
  1134.  END; END;
  1135.  BEGIN
  1136.   IF t = Tree.NoTree THEN RETURN; END;
  1137.   IF (t^.Kind = Tree.Class) THEN
  1138. (* line 859 "" *)
  1139.      WITH t^.Class DO
  1140. (* line 859 "" *)
  1141.       
  1142.     IF (NoCodeClass * Properties) = {} THEN
  1143.        WI (itTree); WriteS (f, " n"); WI (Name); WriteS (f, " () {"); WriteNl (f);
  1144.        WriteS (f, " register "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  1145.        WriteS (f, " yyALLOC (yyt, "); WI (iMain); WriteS (f, "_NodeSize [k"); WI (Name); WriteS (f, "])"); WriteNl (f);
  1146.        WriteS (f, " yyt->Kind = k"); WI (Name); WriteS (f, ";"); WriteNl (f);
  1147.        WriteS (f, " yyt->yyHead.yyMark = 0;"); WriteNl (f);
  1148.      IF IsElement (ORD ('L'), Options) THEN
  1149.        WriteS (f, " yyt->yyHead.yyParent = "); WI (iNoTree); WriteS (f, ";"); WriteNl (f);
  1150.      END;
  1151.        iClassName := Name;
  1152.        ForallAttributes (t, ProcedureBodyn);
  1153.        WriteS (f, " return yyt;"); WriteNl (f);
  1154.        WriteS (f, "}"); WriteNl (f);
  1155.        WriteNl (f);
  1156.     END;
  1157. ;
  1158.       RETURN;
  1159.      END;
  1160.  
  1161.   END;
  1162.   IF (t^.Kind = Tree.Child) THEN
  1163. (* line 876 "" *)
  1164.      WITH t^.Child DO
  1165. (* line 876 "" *)
  1166.       
  1167.     WriteS (f, " begin"); WI (itTree); WriteS (f, "(yyt->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ")"); WriteNl (f);
  1168. ;
  1169.       RETURN;
  1170.      END;
  1171.  
  1172.   END;
  1173.   IF (t^.Kind = Tree.Attribute) THEN
  1174. (* line 879 "" *)
  1175.      WITH t^.Attribute DO
  1176. (* line 879 "" *)
  1177.       
  1178.     IF (NoCodeAttr * Properties) = {} THEN 
  1179.        WriteS (f, " begin"); WI (Type); WriteS (f, "(yyt->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ")"); WriteNl (f);
  1180.     END;
  1181. ;
  1182.       RETURN;
  1183.      END;
  1184.  
  1185.   END;
  1186.  END ProcedureBodyn;
  1187.  
  1188. PROCEDURE ProcedureBodym (t: Tree.tTree);
  1189.  VAR yyTempo: RECORD CASE : INTEGER OF
  1190.  END; END;
  1191.  BEGIN
  1192.   IF t = Tree.NoTree THEN RETURN; END;
  1193.   IF (t^.Kind = Tree.Class) THEN
  1194. (* line 888 "" *)
  1195.      WITH t^.Class DO
  1196. (* line 888 "" *)
  1197.       
  1198.     IF (NoCodeClass * Properties) = {} THEN
  1199.        ProcedureHeadingm (t);
  1200.        WriteS (f, "{"); WriteNl (f);
  1201.        WriteS (f, " register "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  1202.        WriteS (f, " yyALLOC (yyt, "); WI (iMain); WriteS (f, "_NodeSize [k"); WI (Name); WriteS (f, "])"); WriteNl (f);
  1203.        WriteS (f, " yyt->Kind = k"); WI (Name); WriteS (f, ";"); WriteNl (f);
  1204.        WriteS (f, " yyt->yyHead.yyMark = 0;"); WriteNl (f);
  1205.      IF IsElement (ORD ('L'), Options) THEN
  1206.        WriteS (f, " yyt->yyHead.yyParent = "); WI (iNoTree); WriteS (f, ";"); WriteNl (f);
  1207.      END;
  1208.        iClassName := Name;
  1209.        ForallAttributes (t, ProcedureBodym);
  1210.        WriteS (f, " return yyt;"); WriteNl (f);
  1211.        WriteS (f, "}"); WriteNl (f);
  1212.        WriteNl (f);
  1213.     END;
  1214. ;
  1215.       RETURN;
  1216.      END;
  1217.  
  1218.   END;
  1219.   IF (t^.Kind = Tree.Child) THEN
  1220. (* line 906 "" *)
  1221.      WITH t^.Child DO
  1222. (* line 906 "" *)
  1223.       
  1224.     IF Input IN Properties THEN
  1225.        WriteS (f, " yyt->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, " = p"); WI (Name); WriteS (f, ";"); WriteNl (f);
  1226.     ELSE
  1227.        WriteS (f, " begin"); WI (itTree); WriteS (f, "(yyt->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ")"); WriteNl (f);
  1228.     END;
  1229. ;
  1230.       RETURN;
  1231.      END;
  1232.  
  1233.   END;
  1234.   IF (t^.Kind = Tree.Attribute) THEN
  1235. (* line 913 "" *)
  1236.      WITH t^.Attribute DO
  1237. (* line 913 "" *)
  1238.       
  1239.     IF (NoCodeAttr * Properties) = {} THEN 
  1240.        IF Input IN Properties THEN
  1241.           WriteS (f, " yyt->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, " = p"); WI (Name); WriteS (f, ";"); WriteNl (f);
  1242.        ELSE
  1243.           WriteS (f, " begin"); WI (Type); WriteS (f, "(yyt->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ")"); WriteNl (f);
  1244.        END;
  1245.     END;
  1246. ;
  1247.       RETURN;
  1248.      END;
  1249.  
  1250.   END;
  1251.  END ProcedureBodym;
  1252.  
  1253. PROCEDURE ReleaseAttributes1 (t: Tree.tTree);
  1254.  VAR yyTempo: RECORD CASE : INTEGER OF
  1255.  END; END;
  1256.  BEGIN
  1257.   IF t = Tree.NoTree THEN RETURN; END;
  1258.   IF (t^.Kind = Tree.Class) THEN
  1259. (* line 926 "" *)
  1260.      WITH t^.Class DO
  1261. (* line 926 "" *)
  1262.       
  1263.     IF ((NoCodeClass * Properties) = {}) AND (HasChildren IN Properties) THEN
  1264.        WriteS (f, "case k"); WI (Name); WriteS (f, ":"); WriteNl (f);
  1265.        iClassName := Name;
  1266.        ForallAttributes (t, ReleaseAttributes1);
  1267.        WriteS (f, "break;"); WriteNl (f);
  1268.     END;
  1269. ;
  1270.       RETURN;
  1271.      END;
  1272.  
  1273.   END;
  1274.   IF (t^.Kind = Tree.Child) THEN
  1275. (* line 934 "" *)
  1276.      WITH t^.Child DO
  1277. (* line 934 "" *)
  1278.       
  1279.     WriteS (f, "close"); WI (itTree); WriteS (f, " (yyt->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ")"); WriteNl (f);
  1280. ;
  1281.       RETURN;
  1282.      END;
  1283.  
  1284.   END;
  1285.  END ReleaseAttributes1;
  1286.  
  1287. PROCEDURE ReleaseAttributes2 (t: Tree.tTree);
  1288.  VAR yyTempo: RECORD CASE : INTEGER OF
  1289.  END; END;
  1290.  BEGIN
  1291.   IF t = Tree.NoTree THEN RETURN; END;
  1292.   IF (t^.Kind = Tree.Class) THEN
  1293. (* line 941 "" *)
  1294.      WITH t^.Class DO
  1295. (* line 941 "" *)
  1296.       
  1297.     IF ((NoCodeClass * Properties) = {}) AND (HasAttributes IN Properties) THEN
  1298.        WriteS (f, "case k"); WI (Name); WriteS (f, ":"); WriteNl (f);
  1299.        iClassName := Name;
  1300.        ForallAttributes (t, ReleaseAttributes2);
  1301.        WriteS (f, "break;"); WriteNl (f);
  1302.     END;
  1303. ;
  1304.       RETURN;
  1305.      END;
  1306.  
  1307.   END;
  1308.   IF (t^.Kind = Tree.Attribute) THEN
  1309. (* line 949 "" *)
  1310.      WITH t^.Attribute DO
  1311. (* line 949 "" *)
  1312.       
  1313.     IF (NoCodeAttr * Properties) = {} THEN 
  1314.        WriteS (f, "close"); WI (Type); WriteS (f, " (yyt->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ")"); WriteNl (f);
  1315.     END;
  1316. ;
  1317.       RETURN;
  1318.      END;
  1319.  
  1320.   END;
  1321.  END ReleaseAttributes2;
  1322.  
  1323. PROCEDURE TraverseTD (t: Tree.tTree);
  1324.  VAR yyTempo: RECORD CASE : INTEGER OF
  1325.  END; END;
  1326.  BEGIN
  1327.   IF t = Tree.NoTree THEN RETURN; END;
  1328.   IF (t^.Kind = Tree.Class) THEN
  1329. (* line 958 "" *)
  1330.      WITH t^.Class DO
  1331. (* line 958 "" *)
  1332.       
  1333.     IF ((NoCodeClass * Properties) = {}) AND (HasChildren IN Properties) THEN
  1334.        WriteS (f, "case k"); WI (Name); WriteS (f, ":"); WriteNl (f);
  1335.        GetIterator (t);
  1336.        iClassName := Name;
  1337.        ForallAttributes (t, TraverseTD);
  1338.        IF Iterator = NoTree THEN
  1339.           WriteS (f, "return;"); WriteNl (f);
  1340.        ELSE
  1341.           WriteS (f, "yyt = yyt->"); WI (iClassName); WriteS (f, "."); WI (Iterator^.Child.Name); WriteS (f, "; break;"); WriteNl (f);
  1342.        END;
  1343.     END;
  1344. ;
  1345.       RETURN;
  1346.      END;
  1347.  
  1348.   END;
  1349.   IF (t^.Kind = Tree.Child) THEN
  1350. (* line 971 "" *)
  1351.      WITH t^.Child DO
  1352. (* line 971 "" *)
  1353.       
  1354.     IF t # Iterator THEN
  1355.        WriteS (f, "yyTraverse"); WI (iModule); WriteS (f, "TD (yyt->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ");"); WriteNl (f);
  1356.     END;
  1357. ;
  1358.       RETURN;
  1359.      END;
  1360.  
  1361.   END;
  1362.  END TraverseTD;
  1363.  
  1364. PROCEDURE TraverseBU (t: Tree.tTree);
  1365.  VAR yyTempo: RECORD CASE : INTEGER OF
  1366.  END; END;
  1367.  BEGIN
  1368.   IF t = Tree.NoTree THEN RETURN; END;
  1369.   IF (t^.Kind = Tree.Class) THEN
  1370. (* line 980 "" *)
  1371.      WITH t^.Class DO
  1372. (* line 980 "" *)
  1373.       
  1374.     IF ((NoCodeClass * Properties) = {}) AND (HasChildren IN Properties) THEN
  1375.        WriteS (f, "case k"); WI (Name); WriteS (f, ":"); WriteNl (f);
  1376.        GetIterator (t);
  1377.        iClassName := Name;
  1378.        ForallAttributes (t, TraverseBU);
  1379.        IF Iterator = NoTree THEN
  1380.           WriteS (f, "return;"); WriteNl (f);
  1381.        ELSE
  1382.           WriteS (f, "yyTraverse"); WI (iModule); WriteS (f, "BU (yyt->"); WI (iClassName); WriteS (f, "."); WI (Iterator^.Child.Name); WriteS (f, "); break;"); WriteNl (f);
  1383.        END;
  1384.     END;
  1385. ;
  1386.       RETURN;
  1387.      END;
  1388.  
  1389.   END;
  1390.   IF (t^.Kind = Tree.Child) THEN
  1391. (* line 993 "" *)
  1392.      WITH t^.Child DO
  1393. (* line 993 "" *)
  1394.       
  1395.     IF t # Iterator THEN
  1396.        WriteS (f, "yyTraverse"); WI (iModule); WriteS (f, "BU (yyt->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ");"); WriteNl (f);
  1397.     END;
  1398. ;
  1399.       RETURN;
  1400.      END;
  1401.  
  1402.   END;
  1403.  END TraverseBU;
  1404.  
  1405. PROCEDURE Reverse1 (t: Tree.tTree);
  1406.  VAR yyTempo: RECORD CASE : INTEGER OF
  1407.  END; END;
  1408.  BEGIN
  1409.   IF t = Tree.NoTree THEN RETURN; END;
  1410.   IF (t^.Kind = Tree.Class) THEN
  1411. (* line 1002 "" *)
  1412.      WITH t^.Class DO
  1413. (* line 1002 "" *)
  1414.       
  1415.     IF (NoCodeClass * Properties) = {} THEN
  1416.        iClassName := Name;
  1417.        ForallAttributes (t, Reverse1);
  1418.     END;
  1419. ;
  1420.       RETURN;
  1421.      END;
  1422.  
  1423.   END;
  1424.   IF (t^.Kind = Tree.Child) THEN
  1425. (* line 1008 "" *)
  1426.      WITH t^.Child DO
  1427. (* line 1008 "" *)
  1428.       
  1429.     IF Reverse IN Properties THEN
  1430.        WriteS (f, "case k"); WI (iClassName); WriteS (f, ": yyNext = yyOld->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ";"); 
  1431.        WriteS (f, " yyOld->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, " = yyNew; break;"); WriteNl (f);
  1432.     END;
  1433. ;
  1434.       RETURN;
  1435.      END;
  1436.  
  1437.   END;
  1438.  END Reverse1;
  1439.  
  1440. PROCEDURE Reverse2 (t: Tree.tTree);
  1441.  VAR yyTempo: RECORD CASE : INTEGER OF
  1442.  END; END;
  1443.  BEGIN
  1444.   IF t = Tree.NoTree THEN RETURN; END;
  1445.   IF (t^.Kind = Tree.Class) THEN
  1446. (* line 1018 "" *)
  1447.      WITH t^.Class DO
  1448. (* line 1018 "" *)
  1449.       
  1450.     IF (NoCodeClass * Properties) = {} THEN
  1451.        iClassName := Name;
  1452.        ForallAttributes (t, Reverse2);
  1453.     END;
  1454. ;
  1455.       RETURN;
  1456.      END;
  1457.  
  1458.   END;
  1459.   IF (t^.Kind = Tree.Child) THEN
  1460. (* line 1024 "" *)
  1461.      WITH t^.Child DO
  1462. (* line 1024 "" *)
  1463.       
  1464.     IF Reverse IN Properties THEN
  1465.        WriteS (f, "case k"); WI (iClassName); WriteS (f, ": yyTail->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, " = yyOld; break;"); WriteNl (f);
  1466.     END;
  1467. ;
  1468.       RETURN;
  1469.      END;
  1470.  
  1471.   END;
  1472.  END Reverse2;
  1473.  
  1474. PROCEDURE Copy (t: Tree.tTree);
  1475.  VAR yyTempo: RECORD CASE : INTEGER OF
  1476.  END; END;
  1477.  BEGIN
  1478.   IF t = Tree.NoTree THEN RETURN; END;
  1479.   IF (t^.Kind = Tree.Class) THEN
  1480. (* line 1033 "" *)
  1481.      WITH t^.Class DO
  1482. (* line 1033 "" *)
  1483.       
  1484.     IF (NoCodeClass * Properties) = {} THEN
  1485.        WriteS (f, "case k"); WI (Name); WriteS (f, ": (* yyNew)->"); WI (Name); WriteS (f, " = yyt->"); WI (Name); WriteS (f, ";"); WriteNl (f);
  1486.        GetIterator (t);
  1487.        iClassName := Name;
  1488.        ForallAttributes (t, Copy);
  1489.        IF Iterator = NoTree THEN
  1490.           WriteS (f, "return;"); WriteNl (f);
  1491.        ELSE
  1492.           WriteS (f, "yyt = yyt->"); WI (Name); WriteS (f, "."); WI (Iterator^.Child.Name); WriteS (f, ";"); WriteNl (f);
  1493.           WriteS (f, "yyNew = & (* yyNew)->"); WI (Name); WriteS (f, "."); WI (Iterator^.Child.Name); WriteS (f, "; break;"); WriteNl (f);
  1494.        END;
  1495.     END;
  1496. ;
  1497.       RETURN;
  1498.      END;
  1499.  
  1500.   END;
  1501.   IF (t^.Kind = Tree.Child) THEN
  1502. (* line 1047 "" *)
  1503.      WITH t^.Child DO
  1504. (* line 1047 "" *)
  1505.       
  1506.     IF t # Iterator THEN
  1507.        WriteS (f, "copy"); WI (itTree); WriteS (f, " ((* yyNew)->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ", "); 
  1508.           WriteS (f, "yyt->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ")"); WriteNl (f);
  1509.     END;
  1510. ;
  1511.       RETURN;
  1512.      END;
  1513.  
  1514.   END;
  1515.   IF (t^.Kind = Tree.Attribute) THEN
  1516. (* line 1053 "" *)
  1517.      WITH t^.Attribute DO
  1518. (* line 1053 "" *)
  1519.       
  1520.     IF (NoCodeAttr * Properties) = {} THEN 
  1521.        WriteS (f, "copy"); WI (Type); WriteS (f, " ((* yyNew)->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ", "); 
  1522.           WriteS (f, "yyt->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ")"); WriteNl (f);
  1523.     END;
  1524. ;
  1525.       RETURN;
  1526.      END;
  1527.  
  1528.   END;
  1529.  END Copy;
  1530.  
  1531. PROCEDURE CheckAttributes (t: Tree.tTree);
  1532.  VAR yyTempo: RECORD CASE : INTEGER OF
  1533.  END; END;
  1534.  BEGIN
  1535.   IF t = Tree.NoTree THEN RETURN; END;
  1536.   IF (t^.Kind = Tree.Class) THEN
  1537. (* line 1063 "" *)
  1538.      WITH t^.Class DO
  1539. (* line 1063 "" *)
  1540.       
  1541.     IF ((NoCodeClass * Properties) = {}) AND (HasChildren IN Properties) THEN
  1542.        WriteS (f, "case k"); WI (Name); WriteS (f, ":"); WriteNl (f);
  1543.        iClassName := Name;
  1544.        ForallAttributes (t, CheckAttributes);
  1545.        WriteS (f, "break;"); WriteNl (f);
  1546.     END;
  1547. ;
  1548.       RETURN;
  1549.      END;
  1550.  
  1551.   END;
  1552.   IF (t^.Kind = Tree.Child) THEN
  1553. (* line 1071 "" *)
  1554.      WITH t^.Child DO
  1555. (* line 1071 "" *)
  1556.       
  1557.     WriteS (f, "yyResult = yyCheckChild (yyt, yyt->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ", k"); 
  1558.     WI (Type); WriteS (f, ', "'); WI (Name); WriteS (f, '") && yyResult;'); WriteNl (f);
  1559. ;
  1560.       RETURN;
  1561.      END;
  1562.  
  1563.   END;
  1564.  END CheckAttributes;
  1565.  
  1566. PROCEDURE InitTypeRange (t: Tree.tTree);
  1567.  VAR yyTempo: RECORD CASE : INTEGER OF
  1568.  END; END;
  1569.  BEGIN
  1570.   IF t = Tree.NoTree THEN RETURN; END;
  1571.   IF (t^.Kind = Tree.Class) THEN
  1572. (* line 1079 "" *)
  1573.      WITH t^.Class DO
  1574. (* line 1079 "" *)
  1575.       
  1576.     IF (NoCodeClass * Properties) = {} THEN
  1577.        iRange := Name;
  1578.        ForallClasses (Extensions, InitTypeRange2);
  1579.        WriteS (f, " k"); WI (iRange); WriteS (f, ","); WriteNl (f);
  1580.     END;
  1581. ;
  1582.       RETURN;
  1583.      END;
  1584.  
  1585.   END;
  1586.  END InitTypeRange;
  1587.  
  1588. PROCEDURE InitTypeRange2 (t: Tree.tTree);
  1589.  VAR yyTempo: RECORD CASE : INTEGER OF
  1590.  END; END;
  1591.  BEGIN
  1592.   IF t = Tree.NoTree THEN RETURN; END;
  1593.   IF (t^.Kind = Tree.Class) THEN
  1594. (* line 1090 "" *)
  1595.      WITH t^.Class DO
  1596. (* line 1090 "" *)
  1597.       
  1598.     iRange := Name;
  1599. ;
  1600.       RETURN;
  1601.      END;
  1602.  
  1603.   END;
  1604.  END InitTypeRange2;
  1605.  
  1606. PROCEDURE QueryAttributes (t: Tree.tTree);
  1607.  VAR yyTempo: RECORD CASE : INTEGER OF
  1608.  END; END;
  1609.  BEGIN
  1610.   IF t = Tree.NoTree THEN RETURN; END;
  1611.   IF (t^.Kind = Tree.Class) THEN
  1612. (* line 1097 "" *)
  1613.      WITH t^.Class DO
  1614. (* line 1097 "" *)
  1615.       
  1616.     IF ((NoCodeClass * Properties) = {}) AND (HasChildren IN Properties) THEN
  1617.        WriteS (f, "case k"); WI (Name); WriteS (f, ": if (false) ;"); WriteNl (f);
  1618.        iClassName := Name;
  1619.        ForallAttributes (t, QueryAttributes);
  1620.        WriteS (f, "break;"); WriteNl (f);
  1621.     END;
  1622. ;
  1623.       RETURN;
  1624.      END;
  1625.  
  1626.   END;
  1627.   IF (t^.Kind = Tree.Child) THEN
  1628. (* line 1105 "" *)
  1629.      WITH t^.Child DO
  1630. (* line 1105 "" *)
  1631.       
  1632.     WriteS (f, 'else if (yyyIsEqual ("'); WI (Name); WriteS (f, '")) Query'); WI (iModule);
  1633.     WriteS (f, " (yyt->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ");"); WriteNl (f);
  1634. ;
  1635.       RETURN;
  1636.      END;
  1637.  
  1638.   END;
  1639.  END QueryAttributes;
  1640.  
  1641. PROCEDURE IsEqualAttributes (t: Tree.tTree);
  1642.  VAR yyTempo: RECORD CASE : INTEGER OF
  1643.  END; END;
  1644.  BEGIN
  1645.   IF t = Tree.NoTree THEN RETURN; END;
  1646.   IF (t^.Kind = Tree.Class) THEN
  1647. (* line 1113 "" *)
  1648.      WITH t^.Class DO
  1649. (* line 1113 "" *)
  1650.       
  1651.     IF ((NoCodeClass * Properties) = {}) AND
  1652.        (({HasChildren, HasAttributes} * Properties) # {}) THEN
  1653.        WriteS (f, "case k"); WI (Name); WriteS (f, ": return true"); WriteNl (f);
  1654.        iClassName := Name;
  1655.        ForallAttributes (t, IsEqualAttributes);
  1656.        WriteS (f, ";"); WriteNl (f);
  1657.     END;
  1658. ;
  1659.       RETURN;
  1660.      END;
  1661.  
  1662.   END;
  1663.   IF (t^.Kind = Tree.Child) THEN
  1664. (* line 1122 "" *)
  1665.      WITH t^.Child DO
  1666. (* line 1122 "" *)
  1667.       
  1668.     WriteS (f, "&& equal"); WI (itTree); WriteS (f, " (yyt1->"); WI (iClassName); WriteS (f, "."); WI (Name);
  1669.     WriteS (f, ", yyt2->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, ")"); WriteNl (f);
  1670. ;
  1671.       RETURN;
  1672.      END;
  1673.  
  1674.   END;
  1675.   IF (t^.Kind = Tree.Attribute) THEN
  1676. (* line 1126 "" *)
  1677.      WITH t^.Attribute DO
  1678. (* line 1126 "" *)
  1679.       
  1680.     IF (NoCodeAttr * Properties) = {} THEN 
  1681.        WriteS (f, "&& (equal"); WI (Type); WriteS (f, " (yyt1->"); WI (iClassName); WriteS (f, "."); WI (Name);
  1682.        WriteS (f, ", yyt2->"); WI (iClassName); WriteS (f, "."); WI (Name); WriteS (f, "))"); WriteNl (f);
  1683.     END;
  1684. ;
  1685.       RETURN;
  1686.      END;
  1687.  
  1688.   END;
  1689.  END IsEqualAttributes;
  1690.  
  1691. PROCEDURE InitAttributes (t: Tree.tTree);
  1692.  VAR yyTempo: RECORD CASE : INTEGER OF
  1693.  END; END;
  1694.  BEGIN
  1695.   IF t = Tree.NoTree THEN RETURN; END;
  1696.   IF (t^.Kind = Tree.Class) THEN
  1697. (* line 1136 "" *)
  1698.    LOOP
  1699.      WITH t^.Class DO
  1700. (* line 1137 "" *)
  1701.       IF NOT (((NoCodeClass * Properties) = {}) AND (HasChildren IN Properties)) THEN EXIT; END;
  1702. (* line 1138 "" *)
  1703.       WriteS (f, "case k");
  1704. (* line 1138 "" *)
  1705.       WI (Name);
  1706. (* line 1138 "" *)
  1707.       WriteS (f, ":");
  1708. (* line 1138 "" *)
  1709.       WriteNl (f);
  1710. (* line 1139 "" *)
  1711.       GetIterator (t);
  1712. (* line 1140 "" *)
  1713.       iClassName := Name;
  1714. (* line 1141 "" *)
  1715.       gBitCount := BitCount;
  1716. (* line 1142 "" *)
  1717.       ForallAttributes (t, InitAttributes);
  1718. (* line 1143 "" *)
  1719.           IF (Iterator = NoTree) OR NOT (Input IN Iterator^.Child.Properties) THEN
  1720.        WriteS (f, "return;"); WriteNl (f);
  1721.     ELSE
  1722.        WriteS (f, "yyt = yyt->"); WI (iClassName); WriteS (f, "."); WI (Iterator^.Child.Name); WriteS (f, "; break;"); WriteNl (f);
  1723.     END;
  1724. ;
  1725.       RETURN;
  1726.      END;
  1727.    END;
  1728.  
  1729.   END;
  1730.   IF (t^.Kind = Tree.Child) THEN
  1731. (* line 1149 "" *)
  1732.    LOOP
  1733.      WITH t^.Child DO
  1734. (* line 1150 "" *)
  1735.       IF NOT (Input IN Properties) THEN EXIT; END;
  1736. (* line 1151 "" *)
  1737.       WriteS (f, "yyr = yyt->");
  1738. (* line 1151 "" *)
  1739.       WI (iClassName);
  1740. (* line 1151 "" *)
  1741.       WriteS (f, ".");
  1742. (* line 1151 "" *)
  1743.       WI (Name);
  1744. (* line 1151 "" *)
  1745.       WriteS (f, "; yyr->yyHead.yyOffset = ");
  1746. (* line 1152 "" *)
  1747.       WN (gBitCount + BitOffset);
  1748. (* line 1152 "" *)
  1749.       WriteS (f, "; yyr->yyHead.yyParent = yyt;");
  1750. (* line 1152 "" *)
  1751.       WriteNl (f);
  1752. (* line 1153 "" *)
  1753.       IF NOT (t # Iterator) THEN EXIT; END;
  1754. (* line 1154 "" *)
  1755.       WriteS (f, "Init");
  1756. (* line 1154 "" *)
  1757.       WI (iModule);
  1758. (* line 1154 "" *)
  1759.       WriteS (f, " (yyr);");
  1760. (* line 1154 "" *)
  1761.       WriteNl (f);
  1762.       RETURN;
  1763.      END;
  1764.    END;
  1765.  
  1766.   END;
  1767.  END InitAttributes;
  1768.  
  1769. PROCEDURE InitNodeSize (t: Tree.tTree);
  1770.  VAR yyTempo: RECORD CASE : INTEGER OF
  1771.  END; END;
  1772.  BEGIN
  1773.   IF t = Tree.NoTree THEN RETURN; END;
  1774.   IF (t^.Kind = Tree.Class) THEN
  1775. (* line 1159 "" *)
  1776.      WITH t^.Class DO
  1777. (* line 1159 "" *)
  1778.       
  1779.     IF (NoCodeClass * Properties) = {} THEN
  1780.        WriteS (f, " sizeof (y"); WI (Name); WriteS (f, "),"); WriteNl (f);
  1781.     END;
  1782. ;
  1783.       RETURN;
  1784.      END;
  1785.  
  1786.   END;
  1787.  END InitNodeSize;
  1788.  
  1789. PROCEDURE InitNodeName (t: Tree.tTree);
  1790.  VAR yyTempo: RECORD CASE : INTEGER OF
  1791.  END; END;
  1792.  BEGIN
  1793.   IF t = Tree.NoTree THEN RETURN; END;
  1794.   IF (t^.Kind = Tree.Class) THEN
  1795. (* line 1169 "" *)
  1796.      WITH t^.Class DO
  1797. (* line 1169 "" *)
  1798.       
  1799.     IF (NoCodeClass * Properties) = {} THEN
  1800.        WriteS (f, ' "'); WI (Name); WriteS (f, '",'); WriteNl (f);
  1801.     END;
  1802. ;
  1803.       RETURN;
  1804.      END;
  1805.  
  1806.   END;
  1807.  END InitNodeName;
  1808.  
  1809. PROCEDURE CompMaxBit (t: Tree.tTree);
  1810.  VAR yyTempo: RECORD CASE : INTEGER OF
  1811.  END; END;
  1812.  BEGIN
  1813.   IF t = Tree.NoTree THEN RETURN; END;
  1814.   IF (t^.Kind = Tree.Class) THEN
  1815. (* line 1178 "" *)
  1816.      WITH t^.Class DO
  1817. (* line 1179 "" *)
  1818.       i := 1;
  1819. (* line 1180 "" *)
  1820.       ForallAttributes (t, CompMaxBit);
  1821. (* line 1181 "" *)
  1822.       MaxBit := Max (i, MaxBit);
  1823.       RETURN;
  1824.      END;
  1825.  
  1826.   END;
  1827.   IF (t^.Kind = Tree.Child) THEN
  1828. (* line 1183 "" *)
  1829.    LOOP
  1830.      WITH t^.Child DO
  1831. (* line 1185 "" *)
  1832.       IF NOT (({Input, Test, Dummy} * Properties = {})) THEN EXIT; END;
  1833. (* line 1186 "" *)
  1834.       INC (i);
  1835.       RETURN;
  1836.      END;
  1837.    END;
  1838.  
  1839.   END;
  1840.   IF (t^.Kind = Tree.Attribute) THEN
  1841. (* line 1183 "" *)
  1842.    LOOP
  1843.      WITH t^.Attribute DO
  1844. (* line 1185 "" *)
  1845.       IF NOT (({Input, Test, Dummy} * Properties = {})) THEN EXIT; END;
  1846. (* line 1186 "" *)
  1847.       INC (i);
  1848.       RETURN;
  1849.      END;
  1850.    END;
  1851.  
  1852.   END;
  1853.  END CompMaxBit;
  1854.  
  1855. PROCEDURE BeginTreeC1;
  1856.  BEGIN
  1857. (* line 41 "" *)
  1858.  ConstCount := 0; 
  1859.  END BeginTreeC1;
  1860.  
  1861. PROCEDURE CloseTreeC1;
  1862.  BEGIN
  1863.  END CloseTreeC1;
  1864.  
  1865. PROCEDURE yyExit;
  1866.  BEGIN
  1867.   IO.CloseIO; System.Exit (1);
  1868.  END yyExit;
  1869.  
  1870. BEGIN
  1871.  yyf    := IO.StdOutput;
  1872.  Exit    := yyExit;
  1873.  BeginTreeC1;
  1874. END TreeC1.
  1875.